.TITLE	LADRV
	.IDENT	/05.02/
;
; DIGITAL EQUIPMENT CORP., MAYNARD MASS.
;
; Copyright (c) 1995-1999 by Mentec Inc., U.S.A.
; All rights reserved.
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED
; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;
; THIS SOFTWARE IS FURNISHED UNDER  A LICENSE FOR USE ONLY  ON  A
; SINGLE COMPUTER SYSTEM AND MAY BE  COPIED ONLY WITH  THE INCLU-
; SION OF  THE  ABOVE  COPYRIGHT NOTICE.  THIS SOFTWARE,  OR  ANY
; OTHER COPIES THEREOF, MAY NOT BE  PROVIDED  OR  OTHERWISE  MADE
; AVAILABLE TO ANY OTHER PERSON EXCEPT  FOR  USE  ON  SUCH SYSTEM
; AND TO  ONE WHO AGREES  TO  THESE LICENSE  TERMS.  TITLE TO AND
; OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC.
;
; THE INFORMATION IN THIS SOFTWARE  IS  SUBJECT TO CHANGE WITHOUT
; EQUIPMENT CORPORATION.
;
; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.
;
;
;
; CHARLES A. SAMUELSON
; MICHAEL SCHWARTZ
; CLARK A. D'ELIA
;
; NOV. 22, 1977
;
; PREVIOUSLY MODIFIED BY:
;
;      P.K. WEISS
;
; MODIFIED FOR RSX-11M-PLUS V4.5 BY:
;
;	D. CARROLL	15-Feb-1993		05.02
;
;		DC106	-- Insure that the stack is clean across the
;				call to $CFORK on mP systems
;
; LPA11 LABORATORY PERIPHERAL ACCELERATOR CONTROLLER DRIVER
;
;
;
;
; MACRO LIBRARY CALLS
;
	.MCALL	HWDDF$,PKTDF$,TCBDF$,UCBDF$,SCBDF$
	HWDDF$				;DEFINE HARDWARE REGISTERS
	PKTDF$				;DEFINE I/O PACKET OFFSETS
	SCBDF$				;DEFINE STATUS CONTROL BLOCK OFFSETS
	TCBDF$				;DEFINE TASK CONTROL BLOCK OFFSETS
	UCBDF$				;DEFINE UNIT CONTROL BLOCK OFFSETS
;
; QIO DIRECTIVE DESCRIPTIONS
;
;	IO.LOD, ... ,<BUF,2048.>
;		BUF - BUFFER OF MICRO - CODE TO LOAD
;			BUFFER SIZE MUST BE 2048. BYTES
;		ISSUEING TASK MUST BE PRIVILEGED
;		VERIFIES NO ACTIVE USERS FOR LPA11
;		HARDWARE RESETS LPA11
;		LOADS AND VERIFIES MICRO - CODE
;		STARTS LPA11 AND ENABLES INTERRUPTS
;		RETURNS WHEN READY IN INTERRUPT IS POSTED
;		THIS IS A TRANSFER FUNCTION-(THE QIO DOES ADDRESS
;		CHECKS AND RELOCATES THE USER BUFFER)
;
;	IO.INI, ... ,<BUF,278.>
;		BUF - BUFFER CONTAINING LPA11 INITIALIZE RDA
;			BUFFER SIZE MUST BE AT LEAS 278. BYTES
;		ISSUEING TASK MUST BE PRIVILEGED
;		SENDS AN INITIALIZE COMMAND TO LPA11
;
;	IO.CLK, ... ,<MODE,CKCSR,PRESET>
;		MODE - LPA11 CLOCK START MODE WORD
;		CKCSR - IMAGE TO WRITE INTO LPA11 REAL TIME CLOCK CONTROL REGISTER
;		PRESET - IMAGE TO WRITE INTO LPA11 REAL TIME CLOCK PRESET BUFFER REGISTER
;		ISSUES AN LPA11 CLOCK START COMMAND
;
;	IO.STA, ... ,<BUF,40.>
;		BUF - POINTER TO LPA11 SAMPLE START RDA
;			BUFFER SIZE MUST BE AT LEAST 40. BYTES
;		ISSUES AN LPA11 DATA TRANSFER START COMMAND
;		THIS IS A TRANSFER FUNCTION-(THE QIO DOES ADDRESS
;		CHECKS AND RELOCATES THE USER BUFFER)
;
;	  SUBFUNCTION CODE DIFFINTIONS FOR IO.STA
;
;		BIT 0 = 0   GIVE AST FOR EVERY BUFFER IF AST SPECIFIED
;		BIT 0 = 1   GIVE AST ONLY FOR EXCEPTION CONDITIONS
;
;
;	IO.STP, ... ,<USERID>
;
;		CALL MUST SUPPLY LUN
;		USERID - USER INDEX NUMBER <0-7> TO STOP
;		STOPPING TASK MUST BE THE SAME AS STARTING TASK
;
;
; DEFAULT UIC OF LOADER TASK = [1,1]
;
TUIC=401				;DEFAULT UIC OF LOADER TASK
;
;
;
; ASSEMBLY CONDITIONALS 
;
;	M$$MGE				;MEMORY MANAGEMENT
;	A$$CHCK				;ADDRESS CHECK
;	A$$TRP				;AST SUPPORT
;	M$$EXT				;22 BIT 11/70 EXT MEM.
;	M$$PRO				;MULTI-PROCESSOR SUPPORT
;	R$$MPL				;RSX-11M PLUS SUPPORT
;
;
;
; DRIVER DISPATCH TABLE
;
	.IF NDF R$$MPL

	DDT$	LA,L$$A11,<INP,OUT>,,<UCBSV>

	.IFF

	DDT$	LA,L$$A11,<INP,OUT>,,<UCBSV>,<NEW>

	.ENDC
;
	.IF	GT	L$$A11-1
;
TEMP:	.BLKW	1			;TEMP STORAGE FOR CONT. NUM.
;
	.ENDC
;
;
	.PAGE
	.SBTTL	ONLINE/OFFLINE ENTRY POINTS
;
;   CONTROLLER STATUS CHANGE ROUTINE
;
; INPUTS:	R2 = KRB ADDRESS
;
;		C = 0	,BRING CONTROLLER ONLINE
;		C = 1	,TAKE CONTROLLER OFFLINE
;
; OUTPUTS:	$SCERR=	UNCHANGED FOR SUCCESS
;		      =	ERROR CODE FOR FAILURE
;
;
; THE LPA11-K IS BOTH A UNIT AND ITS OWN CONTROLLER. ALL
; THE REAL WORK WILL BE DONE AT THE UNIT ONLINE/OFFLINE ENTRY POINT.
;
	.IF DF R$$MPL

LAKRB:	RETURN				;ALWAYS SUCCESSFUL

;;;;;;;;
;
;    UNIT STATUS CHANGE ROUTINE
;
; INPUTS:	R3 = CONTROLLER INDEX
;		R4 = SCB POINTER
;		R5 = UCB POINTER
;
;		C = 0	,BRING UNIT ONLINE
;		C = 1	,TAKE UNIT OFFLINE
;
; OUTPUTS:	$SCERR=	UNCHANGED FOR SUCCESS
;		      =	ERROR CODE FOR FAILURE
;
;
LAUCB:	BCS	100$
	CALLR	LAPWF			;BRING UNIT ONLINE

100$:	TST	S.PKT(R4)		;ANYONE ACTIVE?
	BNE	200$			;YES, BRANCH
	MOV	#U.LAUT,R0		;POINT TO ACTIVE USER TABLE
	ADD	R5,R0			;   IN THE UCB
	MOV	#8.,R2			;MAXIMUM OF 8. USERS
110$:	TST	(R0)+			;THIS USER ACTIVE?
	BNE	200$			;YES, BRANCH
	DEC	R2			;DECREMENT COUNTER
	BGT	110$			;TRY THE NEXT USER
	MTPS	S.PRI(R4)		;;; LOCK OUT INTERRUPTS
	MOV	#40000,@S.CSR(R4) 	;;; HARDWARE RESET LPA11-K
	MTPS	#0			;;; ALLOW INTERRUPTS
	RETURN				;LPA11-K READY FOR OFFLINE

200$:	MOVB	#IE.RSU&377,$SCERR 	;RESOURCE IN USE ERROR
	RETURN				;NO OFFLINE YET

	.ENDC
	.PAGE
	.SBTTL	LPA11 DRIVER I/O INITIATOR ENTRY POINT - LAINI -**
;
; THIS ROUTINE IS ENTERED FROM THE QUEUE I/O DIRECTIVE WHEN AN I/O REQUEST
; IS RECEIVED FOR THE LPA11 LABORATORY PERIPHERAL ACCELERATOR.  FIVE
; FUNCTIONS ARE RECOGNIZED BY THE LPA11 DRIVER.  SPECIAL USER BUFFERS
; ARE ADDRESS CHECKED WHERE NECESSARY.  ERROR FREE REQUESTS ARE PLACED
; IN THE I/O QUEUE THAT IS MAINTAINED BY THE DRIVER.
;
; ADDRESS CHECKING FOR THE USER'S DBP BUFFER IS DONE IN THE QIO ROUTINE
; BEFORE THIS DRIVER IS CALLED.
; 
; INPUTS:
;
;	R1=ADDRESS OF I/O REQUEST PACKET
;	R4=ADDRESS OF STATUS CONTROL BLOCK
;	R5=ADDRESS OF THE UCB OF THE CONTROLLER TO BE INITIATED
;
; OUTPUTS:
;
;	A QUEUED I/O PACKET WITH USER BUFFERS ADDRESS CHECKED AND
;	RELOCATED.  PACKET MAY BE DEQUEUED WHEN $GTPKT IS CALLED IF
; 	IT IS THE ONLY PACKET IN THE QUEUE.
;
; FUNCTION INDEPENDENT I/O REQUEST PACKET FORMAT:
;
;	WD. 00 -- I/O QUEUE THREAD WORD.
;	WD. 01 -- REQUEST PRIORITY, EVENT FLAG NUMBER
;	WD. 02 -- ADDRESS OF THE TCB OF REQUESTER TASK
;	WD. 03 -- POINTER TO SECOND LUN WORD IN REQUESTER TASK HEADER
;	WD. 04 -- CONTENTS OF THE FIRST LUN WORD IN REQUESTER TASK HEADER
;	WD. 05 -- I/O FUNCTION CODE
;	WD. 06 -- VIRTUAL ADDRESS OF I/O STATUS BLOCK
;	WD. 07 -- RELOCATION BIAS OF I/O STATUS BLOCK
;	WD. 10 -- I/O STATUS BLOCK ADDRESS (READ OR DISPLACEMENT+140000)
;	WD. 11 -- VIRTUAL ADDRESS OF AST SERVICE ROUTINE.
;
;
;
; THE I/O PACKET PARAMETER LIST IS USED BY THE DRIVER TO STORE
; INFORMATION REGARDING THE REQUEST.
; THIS INFORMATION IS CALCULATED AS THE REQUEST IS PROCESSED.
; CONVENTIONS FOR I/O PACKET PARAMETER LIST USEAGE ARE:
;
;
; WD. 12 - I.PRM   -FIRST PARAMETER SUPPLIED BY ISSUEING TASKS QIO
; WD. 13 - I.PRM+2 -SECOND PARAMETER SUPPLIED BY ISSUEING TASKS QIO
; WD. 14 - I.PRM+4 -THIRD PARAMETER SUPPLIED BY ISSUEING TASKS QIO
; WD. 15 - I.PRM+6 -LOW ORDER 16 BITS OF PHYSICAL ADDRESS OF REQUEST RDA
; WD. 16 - I.PRM+10-HIGH ORDER 2 BITS OF PHYSICAL ADDRESS OF REQEUST RDA
; WD. 17 - I.PRM+12-EVENT FLAG MASK FOR CONTINUING DATA TRANSFER REQUEST
; WD. 20 - I.PRM+14-EVENT FLAG ADDRESS
; WD. 21 - I.PRM+16-RESERVED FOR RSX-11M
;
;
;
LAINI:	MOV	R1,-(SP)		;SAVE I/O PACKET ADDRESS
	TST	I.IOSB+4(R1)		;IOSB SUPPLIED?
	BEQ	ELABAD			;NO, BAD PARAMETERS ERR
	MOV	I.FCN(R1),R3		;I/O FUNCTION CODE
	BIC	#377,R3			;CLEAR LOW BYTE
	CMP	#IO.INI,R3		;INITIALIZE REQUEST?
	BNE	5$			;NO, CONTINUE
	JMP	LAINIT			;YES
5$:	CMP	#IO.CLK,R3		;CLOCK START REQUEST?
	BNE	15$			;NO, CONTINUE
	JMP	LACLOK			;YES
15$:	CMP	#IO.STP,R3		;STOP REQUEST?
	BNE	2$			;NO
	JMP	LASTOP			;YES
;
; IT IS EITHER A LOAD MICRO-CODE REQUEST OR A START DATA TRANSFER REQEUST
; COPY USER BUFFER POINTERS SO $GTWRD WILL OPERATE
;
2$:	MOV	I.PRM(R1),U.BUF(R5)	;RELOCATION BIAS
	MOV	I.PRM+2(R1),U.BUF+2(R5)	;OFFSET
	CMP	#IO.STA,R3		;START?
	BNE	3$			;NO
	JMP	LASTRT			;YES
3$:	CMP	#IO.LOD,R3		;LOAD MICRO-CODE?
	BNE	ELAIFC			;NO, ILLEGAL FUNCTION
	JMP	LALOAD			;YES, JMP TO LOAD
;
;
; *******************************************
;
; ** - ERROR HANDLING PATHS FOR LADRV - INITIATOR ENTRY ONLY
;      INTERRUPT ROUTINES AND OTHER ENTRY POINTS REPORT THEIR OWN ERRORS
;
;
ELAIFC:	MOV	#IE.IFC&377,R0		;ILLEGAL FUNCTION ERROR
	BR	EROR				;FINISH ERROR HANDLING
;
ELAPRI:	MOV	#IE.PRI&377,R0		;PRIVILEGE ERROR
	BR 	EROR
;
ELASPC:	MOV	#IE.SPC&377,R0		;USER BUFFER ADDR CHECK ERROR
	BR	EROR
;
ELABCC:	MOV	#IE.BCC&377,R0		;LOAD ERROR FOR MICRO-CODE
	BR	EROR			;EXIT
;
ELARSU:	MOV	#IE.RSU&377,R0		;RESOURCE IN USE - CANNOT INITIALIZE
	BR	EROR
;
ELANOD:	MOV	#IE.NOD&377,R0		;SYSTEM DYNAMIC MEMORY EXHAUSTED
	BR	EROR
;
ELABAD:	MOV	#IE.BAD&377,R0		;BAD PARAMETERS
;
EROR:
	MOV	(SP)+,R3		;ERROR ENCOUNTERED
	CLR	R1			;SET UP IOSB WORD 2
	CALLR	$IOFIN			;I/O COMPLETION
;
;
ELAPR2:	MOV	#IE.PRI&377,R0		;PRIVILEGE ERROR
	BR	ERORGT
;
ELASP2:	MOV	#IE.SPC&377,R0		;USER BUFF ADDR CHECK ERROR
;
ERORGT:	MOV	(SP)+,R3
	CLR	R1
	CALL	$IOFIN
	BR	GETPKT
;
; *******************************************
;
	.PAGE
	.SBTTL	RETREIVE I/O PACKET AND ISSUE REQUEST TO LPA-11
;
; INSERT PACKET IN I/O QUEUE
; THE DRIVER WAS ENTERED BEFORE THE PACKET WAS QUEUED
; NOW WE PUT IT IN THE QUEUE AND GO TO $GTPKT
;
QUEPKT:					;QUEUE AN I/O PACKET FOR THE DRIVER
	MOV	(SP)+,R1		;GET ADDRESS OF PACKET
	MOV	R4,R0			;SCB ADDRESS OF CONTROLLER TO INSERT PACKET INTO
	CLR	I.PRM+16(R1)		;INITIALIZE FLAG WORD
	CALL	$QINSP			;INSERT IN QUEUE
					;AND FALL THROUGH TO $GTPKT
;
; TRY TO RETREIVE AN I/O PACKET AND TRANSMITT TO LPA11
;
GETPKT:
;
; BEFORE WE DEALLOCATE A NEW REQUEST FROM THE CONTROLLERS I/O QUEUE,
; TRY AND FETCH A STOP REQUEST FROM THE STOP REQUEST QUEUE
;
	MOV	U.SCB(R5),R4		;POINT TO SCB
	TSTB	S.STS(R4)		;CONTOLLER BUSY?
	BEQ	198$
	JMP	14$			;YES, GO AWAY
198$:	MOV	U.LASL(R5),R1		;LOOK AT STOP QUEUE
	BEQ	200$			;EMPTY, TRY $GTPKT
	MOV	(R1),U.LASL(R5)		;NEW FIRST ENTRY
	INCB	S.STS(R4)		;SET CONTOLER BUSY
	BISB	#US.BSY,U.STS(R5)	;SET UNIT BUSY
	MOV	R1,S.PKT(R4)		;SET CURRENT I/O PACKET ADDRESS
	MOVB	S.CON(R4),R3		;MOVE CONTROLLER INDEX TO R3

	.IF DF M$$PRO

	CALL	$CFORK			;WE MUST RUN ON CORRECT PROCESSOR

	.ENDC

	BR	210$			;GIVE REQUEST TO LPA11
;
; TRY AND RETREIVE AN I/O PACKET FROM THE CONTROLLERS I/O QUEUE
;
;
200$:	CALL	$GTPKT
	BCS	14$
210$:	MOV	R5,UCBSV(R3)		;SAVE UCB PTR. FOR INT ROUTINE
	BICB	#US.MDM,U.STS(R5)	;CLEAR ABORT CURRENT REQUEST FLAG
	CMP	#IO.LOD,I.FCN(R1)	;A LOAD MICROCODE FUNCTION?
	BNE	220$
	MOVB	S.ITM(R4),S.CTM(R4)	;SET DEVICE TIMEOUT COUNT
	BR	12$
220$:
	.IF DF M$$EXT

	CMP	#IO.INI,I.FCN(R1)	;INITIALIZE RDA?
	BNE	222$			;NO, BRANCH
	MOV	#139.*2,U.CNT(R5)	;LENGTH OF RDA TO BE MAPPED
	MOV	I.PRM+6(R1),U.BUF+2(R5)	;LOW 16 BITS OF RDA ADDRESS
	MOVB	I.PRM+10(R1),U.BUF+1(R5) ;HIGH 6 BITS OF RDA ADDRESS
	CALL	MAP			;GO MAP UMR'S
	MOV	M.UMVL(R3),I.PRM+6(R1)	;LOW 16 BITS OF UMR VIRTUAL ADDRESS
	MOVB	M.UMVH(R3),I.PRM+10(R1)	;HIGH 2 BITS (IN BITS 4 AND 5)
	ASR	I.PRM+10(R1)		;MOVE THOSE ADDRESS BITS
	ASR	I.PRM+10(R1)		;	TO BITS 2 AND 3
	BR	250$

222$:	CMP	#IO.STA,I.FCN(R1)	;START I/O FUNCTION?
	BNE	250$			;NO, BRANCH
	TST	I.PRM+16(R1)		;ANY UMR'S MAPPED?
	BNE	250$			;YES, START CONVERTED TO STOP PACKET
	MOV	I.PRM+2(R1),U.CNT(R5)	;LENGTH OF MAPPED REGION
	MOV	I.PRM+6(R1),R2		;GET RDA ADDRESS
	MOV	4(R2),U.BUF+2(R5)	;USW LOW 16 BITS
	MOVB	6(R2),U.BUF+1(R5)	;USW HIGH 2 BITS
	CALL	MAP			;GO MAP UMR'S
	MOV	R5,-(SP)		;SAVE UCB POINTER
	ADD	#4,R2			;POINT TO USW IN RDA
	MOV	M.UMVL(R3),(R2)+	;POINT LPA TO MAPPED USW
	MOVB	M.UMVH(R3),R5		;GET USW HIGH 2 BITS
	BIC	#^C<377>,R5		;CLEAR HIGH BYTE
	ASRB	R5			;MOVE TO BITS 0 AND 1
	ASRB	R5
	ASRB	R5
	ASRB	R5
	MOVB	R5,(R2)+		;STORE INTO RDA
	MOVB	(R2)+,R0		;GET VALID BUFFER MASK
	BIC	#^C<7>,R0		;ISOLATE MASK BITS
225$:	ADD	M.UMVL(R3),(R2)+	;ADD UMR BASE ADDRESS LOW BITS
	ADC	(R2)			;DONT FORGET THE CARRY
	ADD	R5,(R2)+		;ADD UMR BASE ADDRESS HI 2 BITS
	DEC	R0
	BGE	225$			;BRANCH IF NOT DONE

	MOV	I.PRM+6(R1),R2		;GET THE RDA ADDRESS
	ADD	#50,R2			;INDEX TO RCL ADDRESS
	ADD	M.UMVL(R3),(R2)+	;ADD UMR BASE ADDRESS LOW BITS
	ADC	(R2)			;DONT FORGET THE CARRY
	ADD	R5,(R2)			;ADD THE HIGH BITS

	MOV	(SP)+,R5		;RESTORE UCB POINTER
250$:
	.ENDC

	MOVB	S.ITM(R4),S.CTM(R4)	;SET DEVICE TIMEOUT COUNT
	MOV	S.CSR(R4),R0		;GET DEVICE CSR ADDRESS
	MOV	I.PRM+6(R1),4(R0)	;SET  LOW 16 BITS OF RDA ADDRESS
	BIC	#14,(R0)		;CLEAR PREVIOUS EXTENDED ADDRESS BITS
	MOV	I.PRM+10(R1),R2
	INC	R2			;SET GO BIT
	BIS	R2,(R0)			;GIVE TO LPA
12$:	RETURN
;
; THERE IS NOTHING TO DO FOR THIS UNIT
; CHECK TO SEE IF ANY DYNAMIC STOREAGE NEEDS TO BE DEALLOCATED
;
14$:	TST	(R4)			;BECAUSE I/O LIST IS EMPTY?
	BNE	12$			;NO, JUST EXIT
16$:	MOV	U.LADS(R5),R0		;ANY DSR ALLOCATED?
	BEQ	12$			;NO, EXIT
	MOV	(R0),U.LADS(R5)		;YES, REMOVE THIS PACKET AND POINT TO NEXT
	MOV	#30.*2,R1		;DEALLOCATE 30. WORDS
	CALL	$DEACB			;DEALLOCATE BUFFER
	BR	16$			;CONTINUE TILL NONE LEFT
	.PAGE
;
;	THIS SUBROUTINE SETS UP THE UNIBUS MAPPING REGISTERS NEEDED
;	TO MAP THIS USER'S REQUEST WITH THE FOLLOWING STEPS:
;
;		- GET A WORK BLOCK FROM POOL TO USE AS A MAPPING BLOCK
;		- SET UP THE MAPPING BLOCK BY REQUESTING UMRS FROM EXEC
;		- MAKE SURE WE ARE UNDER THE SYSGEN DEFINED LIMIT
;		- LOAD THE UMRS
;
;
	.IF DF M$$EXT

MAP:	MOV	(SP),-(SP)		;RESERVE A WORD AT TOP OF STACK
	MOV	R1,-(SP)		;SAVE PACKET POINTER
	MOV	R2,-(SP)		;SAVE R2
	MOV	R5,-(SP)		;SAVE UCB POINTER
	MOV	#20.,R1			;GET 10. WORDS
	CALL	$ALOCB			;  FROM POOL
	BCC	10$			;BRANCH IF SUCCESSFUL
	MOV	#IE.NOD&377,-(SP)	;SET ERROR CODE
	BR	15$
10$:	MOV	4(SP),R3		;GET PACKET POINTER
	MOV	R0,I.PRM+4(R3)		;STORE POINTER TO NEW BLOCK
	MOV	(SP),R5			;GET UCB POINTER
	MOV	U.SCB(R5),R4		;GET SCB POINTER
	CLR	(R0)			;INITIALIZE CONTEXT SAVE WORD
	CALL	$STMP1			;SET UP THE UMR'S
	MOV	(SP)+,10(SP)		;MOVE DQUMR POINTER TO TOP OF STACK
	TST	-10(R0)			;WERE WE BLOCKED BY EXEC?
	BNE	12$			;YES, REPORT IT
	MOV	M.UMRN(R0),R3		;GET NUMBER OF UMR'S*4
	ASR	R3			;GET NUMBER OF UMR'S
	ASR	R3
	SUB	R3,U.LAUB+2(R5)		;SUBTRACT FROM TOTAL AVAILABLE
	BGE	20$			;BRANCH IF ALL THERE
	ADD	R3,U.LAUB+2(R5)		;RESTORE TOTAL VALUE
	MOV	#IE.DUN&377,-(SP)	;SET ERROR CODE
	BR	13$
12$:	MOV	#IE.BLK&377,-(SP)	;EXEC BLOCKED DRIVER FOR UMRS
13$:	MOV	R0,R2			;COPY MAPPING BLOCK POINTER
	CALL	$DEUMR			;DEALLOCATE THE UMR'S
	SUB	#10,R0			;POINT TO START OF WORK BLOCK
	MOV	#20.,R1			;10. WORDS LONG
	CALL	$DEACB			;RETURN BLOCK TO POOL
15$:	MOV	(SP)+,R0		;POP ERROR CODE
	MOV	(SP)+,R5		;RESTORE UCB POINTER
	MOV	U.SCB(R5),R4		;RESTORE SCB POINTER
	MOV	(SP)+,R2		;RESTORE R2
	MOV	(SP)+,2(SP)		;MOV PACKET POINTER OVER RETURN ADDR
	TST	(SP)+			;CLEAN STACK
	CLR	S.PKT(R4)		;CLEAR CURRENT PACKET POINTER
	CLRB	S.STS(R4)		;MARK CONTROLLER NOT BUSY
	BICB	#US.BSY,U.STS(R5)	;MARK UNIT NOT BUSY
	JMP	EROR

20$:	MOV	R0,R3			;COPY POINTER TO MAPPING BLOCK
	MOV	(SP)+,R5		;GET UCB POINTER
	MOV	U.SCB(R5),R4		;GET SCB POINTER
	CALL	$MPUB1			;LOAD THE UMR'S
	MOV	(SP)+,R2		;RESTORE R2
	MOV	(SP)+,R1		;RESTORE THE PACKET POINTER
	MOV	#1,I.PRM+16(R1)		;MARK MAPPED
	RETURN

	.ENDC
	.PAGE
	.SBTTL	DEVICE INITIALIZE REQUEST
;
;
; ***** PROCESS AN INITIALIZE REQUEST FOR LPA11 *************
;
; FUNCTION DEPENDENT I/O REQUEST PACKET FORMAT:
;
;	WD. 12 -- VIRTUAL ADDRESS OF RDA BUFFER FOR INITIALIZATION
;	WD. 13 -- LENGTH IN BYTES OF THE INIT RDA BUFFER
;	WD. 14 -- NOT USED
;	WD. 15 -- LOW ORDER 16 BITS OF PHYSICAL RDA ADDR
;	WD. 16 -- HIGH ORDER 2 BITS OF PHYSICAL RDA ADDR-BIT POS. 3 AND 2
;	WD. 17 -- NOT USED
;	WD. 20 -- NOT USED
;
; RDA FORMAT FOR INITIALIZATION COMMAND
;
;	WD. 00 -- MODE WORD-CONTAINS MICROCODE VERSION NO. AND
;			    INITIALIZE CODE (000)
;	WD. 01 THRU 12 -- DEVICE ADDRESSES ON THE I/O BUS
;
;	REMAINDER OF BUFFER IS THE DEDICATED MODE DISPATCH TABLE
;	WHICH IS A TABLE OF CONSTANTS REQUIRED FOR DEDICATED MODE
; PROCESS AN INITIALIZE REQUEST FOR LPA11
;
LAINIT:
	CMP	I.PRM+2(R1),#139.*2	;MUST SPECIFY AT LEAST 139. WORDS
	BHIS	10$
	JMP	ELASPC			;ERROR, RDA TOO SHORT
;
; INITIALIZING TASK MUST BE PRIVILEGED!!!
;
10$:	MOV	I.TCB(R1),R0		;GET TCB OF REQUESTOR TASK
	BIT	#T3.PRV,T.ST3(R0)	;TASK PRIVILEGED?
	BNE	15$
	JMP	ELAPRI			;NO, ERROR
15$:	MOV	I.PRM(R1),R0		;ADDRESS OF RDA
 
	.IF DF	A$$CHK!M$$MGE
 
	MOV	#139.*2,R1		;LENGTH OF INIT RDA IN BYTES
	CALL	$ACHCK			;CALL ADDR CHECK ROUTINE
	BCC	20$
	JMP	ELASPC			;ERROR RETURNED

20$:					;REF LABLE

	.IF DF	R$$MPL

;
; THIS IS HERE BECAUSE IO.INI IS MARKED AS A CONTROL FUNCTION IN THE DCB
; EVEN THOUGH IT IS REALLY A TRANSFER FUNCTION.  THAT WAS DONE TO GET
; THE RDA ADDRESS IN THE CORRECT FORM.
; M DOESNT NEED THIS BECAUSE A TASK IS NOT CHECKPOINTABLE OR SHUFFLEABLE
; IF T.IOC <> 0, AND COMMONS DONT MOVE.
;
	MOV	W.BATT(R2),R2		;POINT TO ATTACHMENT DESC OF BUF
	INCB	A.IOC(R2)		;INCREMENT I/O COUNT
	MOV	(SP),R3			;POINT R3 TO I/O PACKET
	MOV	R2,I.AADA(R3)		;STORE ATT DESC ADDR SO $IOFIN
					;WILL DECREMENT THE I/O COUNT


	.ENDC	;R$$MPL

	.ENDC	;A$$CHK!M$$MGE
 
	CALL	CVTP			;CONVERT RDA ADDRESS TO PHYSICAL ADDRESS
	MOV	(SP),R3			;POINT R3 TO I/O PACKET
	MOV	R1,I.PRM+6(R3)		;SAVE LOW ORDER 16 BITS OF PHYSICAL RDA  ADDRESS

	.IF DF M$$EXT

	ASR	R2			;RIGHT JUSTIFY THE ADDRESS BITS
	ASR	R2

	.ENDC

	MOV	R2,I.PRM+10(R3)		;AND HIGH ORDER 2 BITS
	JMP	QUEPKT			;INSERT PACKET IN I/O QUEUE
	.PAGE
	.SBTTL	PROCESS CLOCK START RDA
;
;
;
; ***** PROCESS LPA11-K REAL TIME CLOCK START RDA *********
;
; FUNCTION DEPENDENT I/O REQUEST PACKET FORMAT:
;
;	WD. 12 -- CLOCK START MODE WORD
;		  CONTAINS  CLO CK ID (A OR B) AND  CLO CK START  CODE
;	WD. 13 -- CLOCK STATUS WORD
;	WD. 14 -- CLOCK PRESET WORD
;	WD. 15 -- LOW ORDER 16 BITS OF RDA ADDRESS
;	WD. 16 -- HIGH ORDER 2 BITS-ALWAYS ZERO FOR THIS FUNCTION BECAUSE
;		  THE RDA IS IN THE I/O PACKET ITSELF WHICH RESIDES IN 
;		  KERNEL ADDRESS SPACE
;	WD. 17 -- NOT USED
;	WD. 20 -- NOT USED
;
;
; RDA FOR CLOCK START COMMAND IS 1ST 3 PARAMETER WORDS IN IO PACKET
;
LACLOK:
	MOV	I.PRM(R1),R0		; INSURE THIS IS A CLOCK START
	BIC	#^C<7>,R0		;ISOLATE LOW THREE BITS
	DEC	R0			;IF A CLOCK START,SHOULD GO FROM 1 TO 0
	BEQ	5$			;YES, LEGAL CLOCK START
	JMP	ELABAD			;NO, BAD PARAMETERS ERROR
5$:	MOV	R1,I.PRM+6(R1)		;MAKE I/O PACKET A CLOCK START RDA
	ADD	#I.PRM,I.PRM+6(R1)	;POINT RDA ADDRESS TO IT
	CLR	I.PRM+10(R1)		;KERNAL MODE IS PHYSICAL ADDRESS
	JMP	QUEPKT
;
;
;
	.PAGE
	.SBTTL	LOAD MICRO CODE 
;
; ******* FUNCTION TO LOAD MICRO CODE ***************
; ALSO DOES A HARDWARE INITIALIZE AND START UP OF LPA11
;
; FUNCTION DEPENDENT I/O REQUEST PACKET FORMAT:
;
;	WD. 12 -- 16 BIT RELOCATION BIAS
;	WD. 13 -- OFFSET
;	WD. 14 -- LENGTH IN BYTES OF MICRO-CODE
;	WD. 15 -- NOT USED
;	WD. 16 -- NOT USED
;	WD. 17 -- NOT USED
;	WD. 20 -- NOT USED
;
; ***** THERE IS NO RDA FOR THE LOAD COMMAND *******
;
LALOAD:
	CMP	I.PRM+4(R1),#1024.*2	;MUST LOAD EXACTLY 1024 MICRO INSTRUCTIONS
	BEQ	5$			;PROPER NUMBER, CONITNUE
	JMP	ELASPC			;ERROR - INCORRECT NUMBER OF BYTES IN BUFFER
;
; LOADING TASK MUST BE PRIVILEGED!!
;
5$:	MOV	I.TCB(R1),R2		;ISSUEING TASK MUST BE PRIVILEGED!
	BIT	#T3.PRV,T.ST3(R2)	;TASK PRIVILEGED?
	BNE	10$			;YES, CONTINUE
	JMP	ELAPRI			;NO, ERROR
;
; CHECK TO MAKE SURE THERE ARE NOT ACTIVE USERS
; WE DON'T WANT TO DO A HARDWARE RESET FOR THE POOR GUY!
;
10$:	TST	S.PKT(R4)		;ANYONE ACTIVE?
	BEQ	15$			;NO, OKAY SO FAR
12$:	JMP	ELARSU			;YES, ERROR
15$:	MOV	#U.LAUT,R0		;POINT TO ACTIVE USER TABLE
	ADD	R5,R0			;IN UCB
	MOV	#8.,R2
20$:	TST	(R0)+			;A USER HERE?
	BNE	12$			;YES, RESOURCE IN USE ERROR
	DEC	R2			;END OF LIST?
	BGT	20$			;NO CONTINUE
;
; HARDWARE RESET LPA11-K
;
	.IF DF M$$PRO

	MOV	(SP)+,S.PKT(R4)		; SAVE I/O PACKET ADDRESS
	CALL	$CFORK			; FORK TO THE RIGHT PROCESSOR
	MOV	S.PKT(R4),-(SP)		; PUT THE PACKET BACK AGAIN
	CLR	S.PKT(R4)		; AND CLEAR THE CURRENT PACKET

	.ENDC

	MTPS	S.PRI(R4)		;;;GO TO PRIORITY OF DEVICE
	MOV	#40000,@S.CSR(R4)	;;;RESET
	MTPS	#0			;;;RESET PRIORITY
;
; GET 1024 WORDS FROM USER BUFFER AND LOAD INTO MICRO PROCESSOR
; CHECK EACH WORD LOADED TO VERIFY
;
	CLR	R0			;R0 IS ADDRESS TO LOAD INTO
	MOV	S.CSR(R4),R1		;POINT R1 TO DEVICE CSR
22$:	CALL	$GTWRD			;GET WORD FROM USER BUFFER
	CLR	(R1)			;CLEAR CSR
	MOV	R0,4(R1)		;SET CRAM ADDRESS
	MOV	(SP),6(R1)		;CRAM CONTENTS
	MOV	#2000,(R1)		;SELECT ADDRESS
	BIS	#20000,(R1)		;WRITE CRAM
	CLR	(R1)			;RESET
;
; NOW VERIFY THAT IT IS THERE FOR GRINNS
;
	MOV	R0,4(R1)		;CRAM ADDRESS
	MOV	#2000,(R1)		;SELECT CRAM AT ADDRESS
	CMP	(SP)+,6(R1)		;DATA EQUAL
	BEQ	26$			; YES,OK
	JMP	ELABCC			;NO, LOAD ERROR FOR MICRO-CODE
26$:	INC	R0			;NEXT WORD
	CMP	R0,#1024.		;END OF WCS?
	BLT	22$			;NOT YET
	MOV	#104000,(R1)		;SET RUN AND ENABLE ARBITRATION
	.REPT	5
	NOP				;WAIT FOR THINGS TO GET GOING
	.ENDR
	BIS	#100,(R1)+		;SET INTERRUPT ENABLE FOR READY IN
	BIS	#100,(R1)		;SET INTERRUPT ENABLE FOR READY OUT
	JMP	QUEPKT
;
;
	.PAGE
	.SBTTL	STOP LPA11 ACTIVE REQUEST
;
; ****** ISSUE A STOP RDA COMMAND TO LPA11-K **********
;
; FUNCTION DEPENDENT I/O REQUEST PACKET FORMAT
;
;	WD. 12 -- USER INDEX TO STOP
;	WORDS 13 THRU 20 NOT USED
;
; THE STOP QIO MUST CONTAIN A LUN (POINT TO CORRECT CONTROLLER)
; ROUTINE USES TCB ADDRESS TO ESTABLISH UNIQUENESS OF REQUEST
; TO STOP. 
;
; ******** NOTE !!!  THIS STOP PACKET IS IMMEDIATELY DEALLOCATED.  THE
; ORIGINAL START PACKET WAS CONVERTED INTO A STOP PACKET IN THE READY
; OUT INT. ROUTINE, AFTER THE START REQUEST WAS ACCEPTED.  IT IS THAT
; PACKET THAT GETS QUEUED FOR THE STOP REQUEST.
;
;
LASTOP:
	MOV	I.PRM(R1),R0		;PARAM IS USER INDEX TO STOP
	BIC	#^C<7>,R0		;INSURE INDEX FROM 0-7
	ASL	R0			;MAKE INTO A WORD INDEX
	ADD	R5,R0			;POINT TO UCB+INDEX
	MOV	U.LAUT(R0),R1		;GET PACKET PTR OF START
	BEQ	40$			;USER NOT ACTIVE
	MOV	(SP),R3			;GET PACKET PTR OF STOP
;
	CMP	I.TCB(R3),I.TCB(R1)	;STOP TASK SAME AS START TASK?
	BNE	40$			;NO, NOT THIS USER
	CLR	U.LAUT(R0)		;CLEAR TABLE ENTRY SO WE WON'T BE HERE AGAIN
					;THIS USER MATCHES!!!!
;
; INSERT THE STOP PACKET INTO THE STOP QUEUE FOR THE LPA11
; A SEPARATE I/O QUEUE IS MAINTAINED BY THE DRIVER FOR STOP FUNCTIONS
;
	MOV	U.LASL(R5),(R1)		;INSERT NEXT ENTRY POINTER INTO CURRENT POINTER
	MOV	R1,U.LASL(R5)		;POINT STOP QUEUE TO THIS ENTRY
;
	CLR	R0			;STATUS IS REQEUST PENDING
36$:	MOV	(SP)+,R3		;ADDRESS OF "STOP" PACKET
	CLR	R1			;IOSB(2) IS ZERO
	CALL	$IOFIN			;DEALLOCATE STOP COMMAND PACKET
	JMP	GETPKT			;LOOK FOR SOMETHING TO DO
;
40$:	MOV	#1,R0			;USER NOT ACTIVE
	BR	36$

;
;
	.PAGE
	.SBTTL	PROCESS START DATA TRANSFER REQUEST
;
; ***** PROCESS START DATA TRANSFER RDA **************
;
; ADDRESS CHECKING AND RELOCATION OF USER DATA BUFFERS IS DONE HERE
;  (BEFORE THE I/O PACKET IS QUEUED)
;
; FUNCTION DEPENDENT I/O REQUEST PACKET FORMAT:
;
;	WD. 12 -- RELOCATION BIAS OF ADDR OF INPUT RDA BUFFER
;	WD. 13 -- INPUT RDA ADDRESS OFFSET
;	WD. 14 -- LENGTH OF INPUT RDA IN BYTES
;	WD. 15 -- LOW ORDER 16 BITS OF PHYSICAL RDA ADDRESS
;	WD. 16 -- HIGH ORDER 2 BITS - ALWAYS ZERO FOR THIS FUNCTION
;		  BECAUSE THE "REAL" RDA BUFFER IS DYNAMICALLY
;		  ALLOCATED IN SYSTEM DYNAMIC MEMORY IE. IN KERNEL
;		  ADDRESS SPACE.
;	WD. 17 -- EVENT FLAG MASK
;	WD. 20 -- EVENT FLAG ADDRESS
;	WD. 21 -- RESERVED FOR RSX-11M
;
; ***** NOTE !!!
;	ONCE THE 1ST TWO I.PRM WORDS HAVE BEEN MOVED FROM THE I/O 
;	PACKET TO THE UCB (FOR USE BY $GTWRD), THESE LOCATIONS ARE
;	NO LONGER NEEDED FOR THE INPUT RDA ADDRESS AND ARE FREE FOR
;	OTHER USEFUL DATA.  THIS ROUTINE STORES THE FOLLOWING INFORMATION
;	IN THESE TWO WORDS:
;
;	WD. 12 -- I.PRM+0-BUFFER WORD COUNT
;	WD. 13 -- I.PRM+2-#WORDS TO BE MAPPED BY UMR'S (22-BIT MODE ONLY)
;
;	THE READY OUT ROUTINE STORES THE FOLLOWING INFORMATION IN THE
;	SECOND OF THESE TWO WORDS:
;
;	WD. 13 -- I.PRM+2 - THE STOP RDA ITSELF
;
;	WHEN THE UMR'S HAVE TO BE MAPPED IN GETPKT, A BLOCK IS ALLOCATED
;	FROM POOL. THE ADDRESS OF THAT BLOCK IS STORED HERE FOR LATER
;	DEALLOCATION FOLLOWING A READY-OUT INTERRUPT:
;
;	WD. 14 -- I.PRM+4-UMR MAPPING BLOCK
;
; NOTE THAT THE ORIGINAL DATA FROM THESE LOCATIONS HAS BEEN SAVED IN
; THE UCB  ENTRY POINT TO THE DRIVER (NEAR LABEL 2$) AT THE
; THE UCB AT THE ENTRY POINT TO THE DRIVER (NEAR LABEL 2$).
;
; NOTE FOR MACRO PROGRAMMERS USING QIOS:
;
; THE FOLLOWING RDA IS NOT THE SAME STRUCTURE AS THE IBUF ARRAY.  THE RDA IS
; A DESCRIPTOR ARRAY PASSED TO THE LPA BY A QIO TO INITIATE A DATA SWEEP.  IBUF
; IS SET UP BY THE SUPPORT ROUTINES TO HOLD PARAMETERS AND STRUCTURES NECESSARY
; TO CONTROL A SWEEP.  THESE INCLUDE BUFFER ADDRESSES, USER AND DEVICE QUEUES,
; FLAG WORDS, USER ID, ETC.  IT ALSO INCLUDES THE USW AND THE IOSB.  THE SUPPORT
; ROUTINES CREATE AN RDA USING THE INFORMATION IN IBUF AND PASS THE RDA TO LADRV.
; 
; THIS DRIVER WAS WRITTEN IN CONJUNCTION WITH THE SUPPORT ROUTINES AND IT EXPECTS
; A CERTAIN STRUCTURE IN IBUF.  THERE ARE ONLY THREE CONSTRAINTS:
;
;	1 - THE IBUF ARRAY MUST BE 80 BYTES LONG
;	2 - THE USW MUST BE THE THIRD WORD OF THE ARRAY
;	3 - THE IOSB PASSED TO THE DRIVER MUST NOT BE THE FIRST TWO WORDS OF THE ARRAY
;
; CONSTRAINT 3 EXISTS BECAUSE THE DRIVER EXPECTS TWO CONSECUTIVE 2-WORD IOSB'S 
; STARTING AT THE ADDRESS THAT IS PASSED IN THE I/O PACKET.  IF THE FIRST TWO
; WORDS WERE SPECIFIED AS THE IOSB, THE DRIVER WOULD OVERWRITE THE USW. 
; THE SUPPORT ROUTINES USE THE FIRST TWO WORDS OF THE ARRAY AS A USER IOSB.  
; THEY HAVE THE DOUBLE IOSB USED BY THE DRIVER LOCATED HIGHER IN THE IBUF ARRAY.  
; THEY COMMUNICATE WITH THE DRIVER USING THE DOUBLE IOSB, AND BEFORE THEY 
; RETURN FROM A CALL THEY MOVE THE APPROPRIATE DATA TO THE USER IOSB.  
; THUS THE REQUIRED FORMAT OF IBUF IS:
;
; WORD 00 	- UNDEFINED  (NOT IOSB)
; WORD 01 	- UNDEFINED  (NOT IOSB)
; WORD 02 	- USW
; WORDS 03-47	- UNDEFINED
;
; WITHIN THESE CONSTRAINTS MACRO PROGRAMMERS MAY SET UP IBUF IN ANY WAY THEY WISH
;
; THE RDA BUFFER AS SET UP BY THE CALLING ROUTINE IS AS FOLLOWS:
;
; WORD 00 - LPA-11 MODE WORD
; WORD 01 - NUMBER OF WORDS TO TRANSFER PER BUFFER
; WORD 02 - ADDRESSS OF USER STATUS WORD
; WORD 03 - LOW BYTE ONLY - VALID BUFFER MASK
; WORD 04 - BUFFER 0 ADDRESS
; WORD 05 - BUFFER 1 ADDRESS
; WORD 06 - BUFFER 2 ADDRESS
; WORD 07 - BUFFER 3 ADDRESS
; WORD 10 - BUFFER 4 ADDRESS
; WORD 11 - BUFFER 5 ADDRESS
; WORD 12 - BUFFER 6 ADDRESS
; WORD 13 - BUFFER 7 ADDRESS
; WORD 14 - ADDRESS OF RANDOM CHANNEL LIST
; WORD 15 - DELAY WORD
; WORD 16 - CHANNEL INCR (HIGH BYTE) / START CHANNEL (LOW BYTE)
; WORD 17 - NUMBER OF CHANNELS TO SAMPLE IN SEQUENCE 
; WORD 20 - NUMBER OF CLOCK OVERFLOWS BETWEEN STARTS OF SEQUENCE
; WORD 21 - EVENT MARK WORD / DIGITAL START WORD
; WORD 22 - START WORD MASK
; WORD 23 - EVENT MARK MASK
; WORD 24 - NUMBER OF ELEMENTS IN RANDOM CHANNEL LIST
;
; THIS ROUTINE CONVERTS THIS INPUT FORMAT RDA INTO THE REAL RDA
; WHICH IS USED BY THE LPA-11.  THIS ROUTINE DOES THE ADDRESS
; CHECKING AND RELOCATION OF USER BUFFERS CONVERTING THEM TO
; 2 WORD PHYSICAL ADDRESSES. IT DOES THE SAME FOR THE RANDOM
; CHANNEL LIST AND USER STATUS WORD.  THE FINAL RDA IS CREATED IN
; TASK DYNAMIC MEMORY AND POINTED TO BY WORDS 15 AND 16 IN THE
; I/O PACKET.
;
LASTRT:
	MOV	#30.*2,R1		;ALLOCATE DYNAMIC STOREAGE
	CALL	$ALOCB
	BCC	42$			;GOT ONE
	JMP	ELANOD
;
; LINK THIS PACKET INTO THE LIST OF DSR FOR THE UNIT
;
42$:	MOV	U.LADS(R5),(R0)		;POINT THIS PACKET TO NEXT PACKET
	MOV	R0,U.LADS(R5)		;POINT LIST TO THIS PACKET
	TST	(R0)+			;POINT R0 TO SECOND WORD OF PACKET
;
	MOV	(SP),R2			;GET I/O PACKET ADDRESS
	MOV	R0,I.PRM+6(R2)		;SAVE ADDRESS OF NEW RDA
	CLR	I.PRM+10(R2)		;EXTENDED ADDRESS IS ZERO
	MOV	R0,R3			;COPY ADDRESS OF NEW RDA
	CALL	$GTWRD			;MODE
	MOV	(SP)+,(R3)
	BIC	#7,(R3)			;MAKE SURE THIS IS A "START" RDA
	BIS	#2,(R3)+
	CALL	$GTWRD			;TRANSFER COUNT
	MOV	(SP),(R3)+		;LEAVE COUNT ON STACK FOR LATER
	BLE	62$			;ERROR, TRANSFER COUNT MUST BE 1-32K
	MOV	(SP),I.PRM(R2)		;SAVE BUFF WORD COUNT
	ASL	(SP)			;MAKE TRANSFER COUNT BYTE VALUE
	CALL	$GTWRD			;USER STATUS WORD ADDRESS
 
	.IF DF	A$$CHK!M$$MGE
 
	MOV	#120,R1			;ADDRESS CHECK ENTIRE IBUF ARRAY
	MOV	(SP),R0			;GET USW ADDRESS
	SUB	#4,R0			;PT TO START OF IBUF(=IOSB ADDR)
	CALL	$ACHCK
	BCS	60$			;ADDRESS CHECK ERROR IF C SET
 
	.ENDC
 
	MOV	(SP),R0			;RESTORE USW ADDRESS
	CALL	CVTP			;RLOCATE USW
	MOV	R1,(R3)+		;SAVE USW ADDRESS LOW
	ASR	R2
	ASR	R2
	MOVB	R2,(R3)+		;SAVE USW ADDRESS HIGH

	.IF DF M$$EXT

	MOV	#76.,R4			;OFFSET FROM USW TO FIRST BUFFER

	.ENDC

	MOV	#8.,-(SP)		;COUNTER FOR EIGHT BUFFERS
	CALL	$GTWRD			;NUMBER OF BUFFERS
	MOVB	(SP),(R3)+		;SAVE IN RDA
	BIC	#^C<7>,(SP)		;AND OUT ALL BUT NUMBER OF BUFFERS
	CLR	-(SP)			;HIGH 2 BITS OF OFFSET
44$:	CALL	$GTWRD			;BUFFER ADDRESS
	MOV	(SP),R0
 
	.IF DF	A$$CHK!M$$MGE
 
	MOV	12(SP),R1		;ADDRESS CHECK
	CALL	$ACHCK
	BCS	154$			;ADDRESS CHECK ERROR
 
	.ENDC
 
	.IF NDF M$$EXT

	MOV	(SP)+,R0		;GET ADDRESS OF BUFFER
	CALL	CVTP
	MOV	R1,(R3)+		;SAVE ADDRESS IN RDA
	ASR	R2
	ASR	R2
	MOV	R2,(R3)+

	.IFF

	TST	(SP)+			;CLEAN STACK
	MOV	R4,(R3)+		;SET BUFFER ADDR AS OFFSET FROM USW
	MOV	(SP),(R3)+		;SET HIGH 2 BITS
	ADD	10(SP),R4		;SPAN PAST THIS BUFFER
	ADC	(SP)			;DONT FORGET THE CARRY

	.ENDC

	DEC	4(SP)			;COUNT DOWN TOTAL BUFFERS
	DEC	2(SP)			;COUNT DOWN BUFFERS TO USE
	BGE	44$			;LOOP TIL DONE
	MOV	(SP)+,R2		;GET HIGH 2 BITS OF OFFSET
	TST	(SP)+			;CLEAN BUFFER TO USE COUNTER
46$:	DEC	(SP)			;ANY BUFFERS NOT IN USE
	BLT	50$			;NO, ALL DONE
	CALL	$GTWRD			;FETCH WORD FROM USER
	TST	(SP)+			;IGNORE
	CLR	(R3)+			;CLEAR NEW RDA
	CLR	(R3)+
	BR	46$			;AND LOOP
50$:	MOV	R2,(SP)			;CLEAR STACK OF BUFFER COUNT
	CALL	$GTWRD			;GET RANDOM CHANNEL LIST ADDRESS
	MOV	(SP)+,R0
 
	.IF DF	A$$CHK!M$$MGE
 
	BEQ	52$			;RCL NOT IN USE IF ADDRESS ZERO
	MOV	#2,R1			;ADDRESS CHECK FIRST WORD
	CALL	$ACHCK
	BCS	57$			;ERROR, BAD BUFFER
52$:
 
	.ENDC
 
	.IF NDF M$$EXT

	CALL	CVTP			;RELOCATE
	MOV	R1,(R3)+		;SAVE IN RDA
	ASR	R2
	ASR	R2
	MOV	R2,(R3)+		;SAVE HIGHT ORDER BITS
	TST	(SP)+			;CLEAN HIGH 2 BITS FROM STACK

	.IFF

	MOV	R4,(R3)+		;OFFSET FROM USW
	MOV	(SP)+,(R3)+		;SET UMR HIGH 2 BITS

	.ENDC

	MOV	#6,-(SP)		;SEVEN MORE ENTRIES IN RDA
54$:	CALL	$GTWRD
	MOV	(SP)+,(R3)+
	DEC	(SP)			;END?
	BGE	54$			;NO, LOOP
	TST	(SP)+

	.IF DF	M$$EXT

	CALL	$GTWRD			;GET RCL LENGTH
	ADD	(SP),R4			;ADD WORD COUNT TWICE TO GET
	ADD	(SP)+,R4		;FINAL LENGTH FOR UMR MAPPING
	MOV	4(SP),R3		;GET PACKET POINTER
	MOV	R4,I.PRM+2(R3)		;SAVE FOR UMR MAPPING
	MOV	(SP),R0		;CHECK THAT REGION STARTING WITH THE USW
	MOV	R4,R1		;AND (R4) BYTES LONG IS WITHIN USER'S
	CALL	$ACHCK		;ADDRESS SPACE. THE USER SHOULD KNOW THAT
	BCS	60$		;HIS IBUF,RCL AND BUFFERS MUST BE CONTIGUOUS
	MOV	U.SCB(R5),R4		;RESTORE SCB POINTER

	.ENDC

	ADD	#4,SP			;CLEAR USW AND COUNT FROM STACK
	MOV	(SP),R3			;GET PACKET POINTER
	MOVB	I.EFN(R3),R0		;CALCULATE EVENT FLAG MASK FOR LATER
	MOV	R5,-(SP)		;SAVE R5
	MOV	I.TCB(R3),R5		;TASK TCB ADDRESS
	CALL	$CEFI			;CONVERT EFN TO MASK AND ADDRESS
	MOV	(SP)+,R5		;RESTORE R5
	MOV	R0,I.PRM+12(R3)		;SAVE EVENT FLAG MASK
	MOV	R1,I.PRM+14(R3)		;AND EVENT FLAG ADDRESS
	JMP	QUEPKT			;FINISH IN COMMON CODE
;
; ERROR - BAD BUFFER ADDRESS
;
154$:	TST	(SP)+
55$:	TST	(SP)+			;CLEAR FROM STACK
56$:	TST	(SP)+			;CLEAR FROM STACK
57$:	TST	(SP)+			;CLEAR FROM STACK
60$:	TST	(SP)+			; CLEAN STACK SOME MORE
62$:	TST	(SP)+			;WHAT A CLEAN STACK!
64$:	JMP	ELASP2			; BAD BUFFER
;
	.PAGE
	.SBTTL	READY IN INTERRUPT PROCESSING
;
; INTERRUPT SUBROUTINE FOR READY IN INTERRUPTS
;
; ********************
; LABEL $LAOUT:: IS ADDED TO CONFORM TO RSX-11M SYSGEN NAMING CONVENTION
; WHICH SPECIFIES THAT FOR DUAL VECTORED DEVICES, THE LOW VECTOR IS
; NAMED $XXINP AND THE HIGH VECTOR IS NAMED $XXOUT.  FOR THE LPA-11 KMC
; MODULE, THE HIGHEST PRIORTY VECTOR (THE OUTPUT) MUST COME FIRST.  THUS
; THE OUTPUT VECTOR IS NAMED $LAINP AND THE INPUT VECTOR IS NAMED $LAOUT
; ********************
;
$LAOUT::
;
;
LARDI::
	INTSV$	LA,PR5,L$$A11,,<UCBSV>
	CALL	$FORK			;;;GO TO FORK LEVEL
;
; FORK PROCESSING FOR READY IN INTERRUPTS
;
	MOV	U.SCB(R5),R4		;POINT TO STATUS CONTROL BLOCK
	CLRB	S.CTM(R4)		;CLEAR DEVICE TIMEOUT COUNTER
	CLRB	S.STS(R4)		;CLEAR CONTROLER STATUS TO NOT BUSY
	BICB	#US.BSY,U.STS(R5)	;CLEAR UNIT BUSY STATUS
	MOV	S.PKT(R4),R3		;REQUEST FINISHED?
	BEQ	70$			;YES
	MOV	#1,R0			;FINISH IT SUCCESSFULLY
	CLR	S.PKT(R4)		;MARK FREE
	BIT	#2,I.PRM+16(R3)		;DID WE RUN OUT OF POOL?
	BEQ	66$			;NO, BRANCH
	BIC	#2,I.PRM+16(R3)		;YES, CLEAR THAT BIT
	MOV	#IE.NOD&377,R0		;SET APPROPRIATE ERROR CODE
66$:	CLR	R1			;SECOND IOSB WORD IS ZERO

	.IF DF M$$EXT

	CMP	#IO.INI,I.FCN(R3)
	BEQ	68$
	CMP	#IO.STA,I.FCN(R3)	;START PACKET CONVERTED TO STOP?
	BNE	69$			;NO, BRANCH
	TST	I.PRM+16(R3)		;ANY UMRS MAPPED?
	BEQ	69$			;NO, BRANCH
68$:	CALL	UNMAP			;YES, UNMAP THEM
	MOV	U.SCB(R5),R4		;RESTORE SCB POINTER
	CALL	$DQUMR			;WAKE UP PROCESS WAITING FOR UMRS
69$:
	.ENDC

	CALL	$IOFIN			;END OF REQUEST PROCESSING
70$:	JMP	GETPKT			;TRY AND GET ANOTHER PACKET
;
	.PAGE
	.SBTTL	LPA11-K READY OUT INTERRUPT PROCESSING
;
; INTERRUPT SUBROUTINE FOR LPA11 READY OUT INTERRUPTS
;
; ******************
; LABEL $LAINP:: IS ADDED TO CONFORM TO RSX-11M SYSGEN NAMING CONVENTION
; SEE COMMENT AT INPUT INTERRUPT FOR FURTHER EXPLANATION.
; ******************
;
$LAINP::
;
LARDO::
	INTSV$	LA,PR5,L$$A11,,<UCBSV>
	MOV	#U.LAFB+6,R4		;;;POINT TO READY OUT FORK BLOCK
	ADD	R5,R4			;;;
	CALL	$FORK1			;;;GO TO FORK LEVEL
;
; FORK PROCESSING FOR LPA11 READY OUT INTERRUPTS
;
	MOV	U.SCB(R5),R4		;POINT TO SCB
	MOV	S.CSR(R4),R2		;DEVICE CSR ADDRESS
	MOV	2(R2),R0		;LPA11 OUT STATUS WORD
	MOV	6(R2),R1		;GET MAINTENANCE STATUS BYTE
	BIC	#200,2(R2)		;ACKNOWLEDGE READY OUT INTERRUPT
	MOV	R0,R3			;GET USER INDEX
	ASL	R3			;MAKE WORD OFFSET
	BIC	#^C<16>,R3
	ADD	R5,R3			;POINT TO USRTB IN UCB
	BIC	#377,R0			;AND OUT READY OUT BYTE
	BEQ	100$			;EQUAL IS START REQUEST PROCESSED
	BPL	71$			;POSITIVE IS NORMAL STATUS
	JMP	102$			;MINUS IS ERROR
;
; COMMON CODE FOR REPORTING NORMAL USER STATUS
;
71$:
	MOV	U.LAUT(R3),R2		;GET I/O PACKET ADDRESS IN R2
	MOV	I.PRM(R2),R1		;SET WORD COUNT IN IOSB WD. 2
;					IOSB WD. 1 =400 FROM LPA11-K
72$:
	MOV	R5,-(SP)		;SAVE UCB
	MOV	R3,-(SP)		;SAVE USRTB POINTER
	MOV	U.LAUT(R3),R3		;POINT R3 TO I/O PACKET
	BEQ	75$			;IF NO USER NOW, JUST EXIT
	MOV	I.TCB(R3),R2		;POINT TO REQUESTING TASK TCB
	BIT	#T2.ABO,T.ST2(R2)	;TASK BEING ABORTED?
	BNE	75$			;YES, SKIP EVENT FLAG 
	MOV	I.IOSB+2(R3),R4		;GET IOSB BIAS
	MOV	I.IOSB+4(R3),R2		;GET IOSB OFFSET
	ADD	#4,R2			;POINT TO 2ND IOSB
	CMP	#140100,R2		;MAPPING STILL VALID?
	BHI	172$			;YES, BRANCH
	SUB	#64.,R2			;NO, MAP NEXT 32-WORD BLOCK
	INC	R4
172$:
 
	.IF DF	M$$MGE
 
	MOV	KISAR6,-(SP)		;SAVE KISAR6
	MOV	R4,KISAR6		;MAP USER'S IOSB
 
	.IFTF
 
	MOV	R0,(R2)+		;STORE STATUS BYTE
	MOV	R1,(R2)			;IOSB HIGH WORD
 
	.IFT
 
	MOV	(SP)+,KISAR6		;RESTORE MAPPING
 
	.ENDC
;
; ***************************************************
;

73$:
 
	.IF DF	A$$TRP
 
;
; IF BIT 0 OF THE QIO FUNCTION CODE IS SET, DO NOT QUEUE AST HERE
;
	BIT	#1,I.FCN(R3)			;IS SUBFUNCTION CODE BIT 0 SET?
	BNE	74$				;YES, DO NOT QUEUE AST
;
	TST	I.AST(R3)		;AST REQUESTED?
	BEQ	74$			;NO
	MOV	#6.*2,R1		;YES, ALLOCATE AN AST BLOCK
	CALL	$ALOCB
	BCS	77$			;ERROR, NO DYNAMIC MEMORY
	MOV	R0,R1			;COPY BLOCK ADDRESS
	TST	(R0)+			;POINT PAST AST LIST LINK WORD
	MOV	#6.*2,(R0)+		;SIZE OF AST BLOCK
	MOV	#8.*2,(R0)+		;NUMBER OF BYTES TO ALLOCATE ON USER'S STACK
	MOV	I.AST(R3),(R0)+		;AST VIRTUAL ADDRESS
	MOV	#1,(R0)+		;NUMBER OF EXTRA WORDS TO PUT ON USER'S STACK
	MOV	I.IOSB(R3),(R0)		;IOSB ADDRESS
	ADD	#4,(R0)			;POINT TO 2ND IOSB BLOCK
	MOV	I.TCB(R3),R0		;POINT TO TASK'S TCB
	ADD	#T.ASTL,R0		;POINT TO TASK'S AST LISTHEAD
	CALL	$QINSF			;INSERT AST BLOCK IN TASK'S AST LIST
74$:
 
	.ENDC
 
	MOV	I.TCB(R3),R5		;POINT TO TASK TCB
	MOV	I.PRM+12(R3),R0		;SET ARGS FOR SETM
	MOV	I.PRM+14(R3),R1
	CALL	$SETM
;
;
75$:
	CMP	(SP)+,(SP)+		;CLEAN STACK
 
;
76$:	RETURN				;RETURN
;
;
 
;
;  WE RAN OUT OF POOL FOR AST BLOCK. QUEUE STOP PACKET FOR THIS USER
;  AND SET BIT 2 OF I.PRM+16 TO SET UP PROPER ERROR CODE.
;
	.IF DF	A$$TRP
 
77$:	MOV	(SP)+,R3		;POP USER TABLE POINTER
	MOV	(SP)+,R5		;POP UCB POINTER
	MOV	U.LAUT(R3),R2		;GET THIS USER'S CONVERTED PACKET
	CLR	U.LAUT(R3)		;DEACTIVATE THIS ENTRY
	MOV	U.LASL(R5),(R2)		;MOVE STOP QUEUE BEHIND THIS USER
	MOV	R2,U.LASL(R5)		;SET NEW QUEUE HEADER
	BIS	#2,I.PRM+16(R2)		;MARK FOR 'NO POOL' ERROR
	JMP	GETPKT			;TRY TO DEALLOCATE STOP PACKET
 
	.ENDC
 
;
;
;
; STATUS RETURN OF ZERO
; TRANSFER REQUEST SUCCESSFULLY STARTED
;
100$:
	MOV	S.PKT(R4),R2		;GET CURRENT I/O PACKET ADDRESS
	MOV	R2,U.LAUT(R3)		;STORE IT IN USRTB
	MOV	R3,R1			;RETURN INDEX TO USER
	SUB	R5,R1			;GET INDEX BACK
	ASR	R1
	CLR	S.PKT(R4)		;RELINQUISH CURRENT PACKET
;
; THE FOLLOWING CODE TURNS THE ORIGONAL START REQUEST I/O PACKET
; INTO A STOP PACKET FOR ITSELF.  THIS ALLOWS ANYONE TO STOP THE
; REQUEST BY SIMPLY RE-QUEUEING THIS PACKET.
;
	MOVB	R1,I.PRM+3(R2)		;USER I.D.
	MOVB	#3,I.PRM+2(R2)		;STOP!
	MOV	R2,I.PRM+6(R2)		;ADDRESS OF STOP RDA WE JUST MADE
	ADD	#I.PRM+2,I.PRM+6(R2)	;ADD IN OFFSET TO PROPER PLACE
	CLR	I.PRM+10(R2)		;CLEAR EXTENDED BITS
; ABOVE 5 INSTR. CREATE 1 WORD STOP RDA WHICH RESIDES IN IPRM+2.
; 
	BITB	#US.MDM,U.STS(R5)	;CANCEL I/O REQUESTED?
	BNE	101$			;YES, GO CANCEL
	CLR	R0			;IOSB WORD 1 ON ACCEPT START
;
; TIMEOUT RAISED TO 255 SEC. IN CASE USER SPECIFIED AN EXTREMELY SLOW
; CLOCK RATE AND IS USING DEDICATED MODE. AFTER THE LPA GETS THE FIRST
; 256 WORDS OF DATA, IT WILL ISSUE A READY-IN. THE DRIVER WILL CLEAR
; THE TIMEOUT THERE. IF THE LPA WILL BE WAITING LONGER THAN 255 SECONDS
; BEFORE IT CAN ISSUE A READY-IN (DATA SWEEP DELAYED FOR HOURS FOR
; INSTANCE) THIS TIMEOUT CAN BE DISABLED HERE (AND ONLY HERE).
;
; ANY READY-IN WILL CLEAR THE TIMEOUT. THUS, IF THE DRIVER RECEIVES
; ANOTHER REQUEST SUCH AS A CLOCK QIO, THE TIMEOUT LENGTHENED HERE
; WILL BE NULLIFIED WHEN THE LPA ISSUES THE READY-IN FOLLOWING THE
; CLOCK REQUEST.
;
	MOVB	#255.,S.CTM(R4)		;STRETCH TIMEOUT COUNT NOW
	JMP	72$			;NO, CONTINUE
;
; US.MDM FLAGS THAT A CANCEL I/O OCCURED FOR TASK WHILE START REQUEST WAS
; IN PROGRESS.  IMMEDIATELY QUEUE A STOP FOR THIS USER INTO THE DRIVERS
; STOP REQUEST QUEUE.
;
101$:	MOV	U.LAUT(R3),R1		;POINT TO ORIGINAL I/O PACKET
	CLR	U.LAUT(R3)		;FLAG THAT THE REQUEST IS BEING STOPPED
	MOV	U.LASL(R5),(R1)		;INSERT IN DRIVERS STOP REQUEST QUEUE
	MOV	R1,U.LASL(R5)		;POINT TO IT
	RETURN				;BACK TO CALLER
;
; ERROR REPORTED (STATUS RETURN NEGATIVE)
; DISPATCH ON ERROR BITS
;
102$:
	MOV	R0,R2			;COPY STATUS
	BIC	#^C<160000>,R2		;EXTRACT ERROR TYPE FIELD
	CMP	R2,#160000		;FATAL HARDWARE ERROR?
	BNE	104$			;NO
	BISB	#IE.FHE&377,R0		;YES, SET RSX ERROR CODE
	CLRB	S.CTM(R4)		;NO TIME OUTS NOW
	BR	LAOUT2			;REPORT ERROR TO USERS
104$:
	CMP	R2,#140000		;START ERROR?
	BEQ	106$			;YES
	MOV	U.LAUT(R3),R2		;USER ERROR, GET I/O PACKET PNTR
	BEQ	76$			;USER NOT ACTIVE NOW
	CLR	U.LAUT(R3)		;DEACTIVATE THE USER
	MOV	R2,R3			;COPY I/O PACKET ADDRESS
	CMP	#124000,R0		;RESULT OF USW BIT 14 STOP?
	BNE	103$			;NO
	MOVB	#IS.SUC&377,R0		;YES, SET RSX STATUS AS SUCCESS
					;SIGN EXTEND 0 TO HIGH BYTE
	MOV	I.PRM(R2),R1		;SET WORD COUNT IS IOSB WORD 2
	BR	111$			;FINISH
103$:
	CMP	#121400,R0		;BUFFER OVERRUN/UNDERRUN ERROR?
	BNE	110$			;NO
	BISB	#IE.DAO&377,R0		;SET RSX OVERRUN ERROR STATUS
	BR	111$			;FINISH
106$:
	MOV	S.PKT(R4),R3		;START ERROR, GET I/O PACKET POINTER
	BEQ	76$			;NO USER HERE NOW
	CLR	S.PKT(R4)		;CLEAR PACKET POINTER
110$:
	BISB	#IE.ABO&377,R0		;SET RSX STATUS AS ABORT
111$:
	.IF DF M$$EXT

	TST	I.PRM+16(R3)		;ANY UMRS MAPPED?
	BEQ	113$			;NO, BRANCH
	CALL	UNMAP			;YES, UNMAP AND DEALLOCATE THEM
	MOV	U.SCB(R5),R4		;GET SCB POINTER
	CALL	$DQUMR			;WAKE UP WAITING PROCESS

	.ENDC

113$:	CALLR	$IOFIN			;FLUSH THE PACKET
;
	.PAGE
	.SBTTL	DEVICE TIME-OUT AND POWERFAIL LOGIC
;
; DEVICE TIME-OUT AND DEVICE POWER FAIL
; RESET LPA11
; SET I/O COMPLETION FOR ALL USERS WITH STATUS OF IE.PWR
;
;
; POWER FAIL ----
;	REQUEST LOADER TASK IF PRESENT
;
LAPWF:
 

	.IF DF R$$MPL

	BCC	115$		; IF CC, UNIT POWERFAIL RECOVERY
	RETURN			; IF CS, CONTROLLER RECOVERY, RETURN
115$:

	.ENDC

 
	.IF DF M$$MGE & L$$DRV & LD$LA
 
	MOV	S.FRK+8.(R4),U.LAFB+8.(R5)	;INITIALIZES FORK BLOCK IN UCB FOR
						;FORK1 CALL.  NEEDED FOR MAPPED
 						;SYSTEMS WITH LOADABLE DRIVERS
	.ENDC
 
 
	MOV	R5,R3			;LOADER TASK NAME
	ADD	#U.CW2,R3		;IN UCB  U.CW2 AND U.CW3
	CALL	$SRSTD			;IS IT INSTALLED IN SYSTEM?
	BCS	112$			;NO, DON'T LOAD ON STARTUP
	MOV	#TUIC,R1		;DEFAULT UIC OF LOADER TASK
	MOV	R4,-(SP)		;SAVE R4 AND R5
	MOV	R5,-(SP)
	CALL	$TSKRT			;REQUEST LOADER TASK TO RUN
	MOV	(SP)+,R5		;RESTORE R5 AND R4
	MOV	(SP)+,R4
112$:	MOV	#IE.VER&377,R0		;UNRECOVERABLE ERROR
	CLRB	S.CTM(R4)		;CLEAR TIME OUT COUNTER
	CLR	R1			;ZERO IOSB+2
	BR	LAOUT2			;LET ANY ACTIVE USERS KNOW
;
; DEVICE TIME OUT
;
LAOUT:
	.IF DF M$$PRO

	CALL	$CFORK			;CORRECT PROCESSOR

	.ENDC

	MOV	2(R2),R1		;;;GET LAST READY OUT STATUS
					;;;DATA MAY BE IRRELEVANT
	CLRB	R1			;;;CLEAR LOW BYTE
	BIS	R1,R0			;;;COMBINE LPA STATUS WITH IE.DNR
	MOV	6(R2),R1		;;;GET MAINTENANCE STATUS WORD
LAOUT2:	MOVB	S.PRI(R4),@#PS		;;;GO TO PRIORITY OF DEVICE
	MOV	#40000,@S.CSR(R4)	;;;DO A DEVICE RESET TO MAKE SURE
	CLRB	@#PS			;;;RESET PRIORITY
	CLRB	S.STS(R4)		;CLEAR CONTROLLER STATUS TO NOT BUSY
	BICB	#US.BSY,U.STS(R5)	;CLEAR UNIT BUSY STATUS
	BICB	#US.MNT,U.STS(R5)	;UNMAPPING FLAG
	MOV	S.PKT(R4),R3		;A REQUEST IN PROCESS?
	BEQ	116$			;NO

	.IF DF M$$EXT

	TST	I.PRM+16(R3)		;ANY UMR'S MAPPED?
	BEQ	114$			;NO, BRANCH
	CALL	UNMAP			;DEALLOCATE THE UMR'S
	BISB	#US.MNT,U.STS(R5)	;MARK UMRS DEALLOCATED
114$:
	.ENDC

	CALL	$IOFIN			;DEALLOCATE PACKET
	MOV	U.SCB(R5),R4		;POINT TO SCB
	CLR	S.PKT(R4)		;CLEAR CURRENT PACKET POINTER
116$:	MOV	#-7,-(SP)
	MOV	#U.LAUT,R2
	ADD	R5,R2			;POINT TO USRTB IN UCB
120$:	MOV	(R2),R3			;NEXT ENTRY
	BEQ	122$			;NO REQUEST ACTIVE
	MOV	R2,-(SP)

	.IF DF M$$EXT

	TST	I.PRM+16(R3)		;ANY UMR'S MAPPED?
	BEQ	121$			;NO, BRANCH
	CALL	UNMAP			;DEALLOCATE THE UMR'S
	BISB	#US.MNT,U.STS(R5)	;MARK UMRS DEALLOCATED
121$:
	.ENDC

	CALL	$IOFIN			;REQEUST ACTIVE, TELL HIM ITS OVER
	MOV	(SP)+,R2
122$:	CLR	(R2)+			;CLEAR ENTRY
	INC	(SP)			;ANY MORE ENTRIES IN LIST?
	BLE	120$			;YES, CONTINUE
	TST	(SP)+			;ALL DONE, EXIT

	.IF DF M$$EXT

	MOV	U.LAUB(R5),U.LAUB+2(R5)	;INITIALIZE #OF AVAILABLE UMRS
	BITB	#US.MNT,U.STS(R5)	;ANY UMR'S DEALLOCATED?
	BEQ	LACANG			;NO, BRANCH
	CALL	$DQUMR			;DEQU WAITING PROCESS
	BICB	#US.MNT,U.STS(R5)	;CLEAR UMR DEALLOCATED FLAG

	.ENDC

	BR	LACANG
;
	.PAGE
;
; *********************************
;
;	THIS SUBROUTINE WILL UNMAP THIS USER'S UMRS AND RETURN THEM TO
;	THE LPA POOL. IT WILL DEALLOCATE THE WORK BLOCK TAKEN FROM DSR
;	IN SUBROUTINE 'MAP'.
;
	.IF DF M$$EXT

UNMAP:	MOV	I.PRM+4(R3),R2		;GET ADDRESS OF WORK BLOCK
	ADD	#10,R2			;POINT TO MAP AREA
	MOV	R3,-(SP)		;SAVE PACKET POINTER
	MOV	M.UMRN(R2),R3		;GET #OF UMRS TO RECOVER
	ASR	R3
	ASR	R3
	ADD	R3,U.LAUB+2(R5)		;RECOVER THE UMRS
	CALL	$DEUMR			;DEALLOCATE THE UMR'S
	MOV	(SP),R3			;RESTORE PACKET POINTER
	MOV	R0,-(SP)		;SAVE IOSB
	MOV	R1,-(SP)		;SAVE IOSB+2
	MOV	R5,-(SP)		;SAVE UCB POINTER
	MOV	I.PRM+4(R3),R0		;GET ADDRESS OF WORK BLOCK
	MOV	#20.,R1			;WORK BLOCK IS 10. WORDS
	CALL	$DEACB			;RETURN WORK BLOCK TO POOL
	MOV	(SP)+,R5		;RESTORE UCB POINTER
	MOV	(SP)+,R1		;RESTORE IOSB+2
	MOV	(SP)+,R0		;RESTORE IOSB
	MOV	(SP)+,R3		;RESTORE PACKET POINTER
	CLR	I.PRM+16(R3)		;MARK UNMAPPED
	RETURN

	.ENDC
	.PAGE
	.SBTTL	CANCEL I/O ENTRY
;
; CANCEL I/O FOR A PARTICULAR TASK
; ALL REQUESTS ARE SCANNED FOR THE TCB OF THE TASK
; EACH ACTIVE REQUEST FOR THE TASK IS MARKED FOR ABORT
; ACTUAL REQUEST STOP IS ISSUED AT READY IN INTERRUPT TIME
;
LACAN:
	MOV	#U.LAUT,R0		;;;POINT TO ACTIVE REQUEST TABLES
	ADD	R5,R0			;;;IN UCB
	MOV	#8.,R2			;;;NINE POSSIBLE ENTRIES + CURRENT ENTRY
	MOV	S.PKT(R4),R3		;;;REQUEST IN PROGRESS?
	BEQ	126$			;;;NO REQUEST IN PROCESS
	CMP	I.TCB(R3),R1		;;;TCB'S MATCH?
	BNE	126$			;;;NO, DON'T CANCEL IT
	BISB	#US.MDM,U.STS(R5)	;;;YES, MARK REQ. FOR ABORT WHEN IT FINISHES
126$:	MOV	(R0)+,R3		;;;NEXT USER ACTIVE?
	BEQ	130$			;;;NO
	CMP	I.TCB(R3),R1		;;;TASK TCB'S MATCH?
	BNE	130$			;;;NO
;
; STOP THE REQUEST BY PLACING THE ORIGONAL I/O PACKET INTO THE DRIVERS
; STOP I/O QUEUE
;
	MOV	U.LASL(R5),(R3)		;;;INSERT NEXT INTO NEW CURRENT
	MOV	R3,U.LASL(R5)		;;;INSERT CURRENT AS FIRST
;
	CLR	-2(R0)			;;;DEALLOCATE USER TABLE
130$:	DEC	R2			;;;NEXT USER
	BGT	126$			;;;STILL SOME TO CHECK
	MTPS	#0			;;;RESET PRIORITY
LACANG:	JMP	GETPKT			;GO TO GET A PACKET IF WE CAN
	.PAGE
	.SBTTL	MISC SERVICE ROUTINES
;
; CONVERT VIRTUAL ADDRESS TO PHYSICAL ADDRESS
; ENTRY
;	R0 - CONTAINS VIRTUAL ADDRESS
;
; EXIT
;	R0 - DESTROYED
;	R1 - PHYSICAL ADDRESS BITS 0-15
;	R2 - PHYSICAL ADDRESS BITS 16-17
;	R3, R4, R5 PRESERVED
;
CVTP:
 
	.IF DF	M$$MGE
 
	MOV	R0,R2			;COPY VIRTUAL ADDRESS
	SWAB	R2			;EXTRACT APR NUMBER
	.REPT	4
	ASR	R2
	.ENDR
	BIC	#^C<16>,R2
	MOV	UISAR0(R2),R2		;PAGE ADDRESS FIELD FROM KT11
	MOV	R0,R1			;COPY VIRTUAL ADDRESS
	ASL	R1			;EXTRACT BLOCK NUMBER
	ASL	R1
	SWAB	R1
	BIC	#^C<177>,R1		;BLOCK NUMBER
	ADD	R2,R1			;BLOCK NUMBER+PAGE ADDRESS BLOCK
	MOV	R1,R2
	SWAB	R2			;EXTRACT BITS 16-17

	.IF NDF M$$EXT

	BIC	#^C<14>,R2		;PHYSICAL ADDRESS BITS 16-17

	.IFF

	BIC	#^C<374>,R2		;PHYSICAL ADDRESS BITS 16-21

	.ENDC

	.REPT	6			;GET BLOCK * 64.
	ASL	R1
	.ENDR
	BIC	#^C<77>,R0
	ADD	R0,R1			;PHYSICAL ADDRESS BITS 0-15
 
	.IFF
 
	MOV	R0,R1			;LOW 16 BITS IS PHYSICAL ADDRESS
	CLR	R2
 
	.ENDC
 
	RETURN
	.END